IRIX Base Documentation 2002 November/SGI IRIX Base Documentation 2002 November.iso/usr/share/catman/p_man/cat3/librw/RWAuditStreamBuffer.z/RWAuditStreamBuffer

Text File | 2002-10-03 | 14.7 KB | 331 lines

RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr((((3333CCCC++++++++))))                            RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr((((3333CCCC++++++++))))



NNNNaaaammmmeeee
     RWAuditStreamBuffer - Rogue Wave library class

SSSSyyyynnnnooooppppssssiiiissss
              #include <rw/auditbuf.h>



              #include <iostream.h>
          RWAuditStreamBuffer buf(arguments)
          ostream os(&buf); // may be used for ostreams
          istream is(&buf); // or istreams of any kind



DDDDeeeessssccccrrrriiiippppttttiiiioooonnnn
     Class RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr is used to construct a stream, after which the
     RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr instance will count all the bytes that pass through
     the stream.  If constructed with a function pointer, RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr
     will call that function with each byte that passes through the stream.
     The counting capacity provides for streams the equivalent of the
     RRRRWWWWCCCCoooolllllllleeeeccccttttaaaabbbblllleeee method rrrreeeeccccuuuurrrrssssiiiivvvveeeeSSSSttttoooorrrreeeeSSSSiiiizzzzeeee(((()))) which is only available for
     RRRRWWWWFFFFiiiilllleeee.

PPPPeeeerrrrssssiiiisssstttteeeennnncccceeee
     None

SSSShhhhoooorrrrtttt EEEExxxxaaaammmmpppplllleeee
              #include <rw/auditbuf.h>



              #include <rw/bstream.h>
          #include <rw/pstream.h>
          #include <iostream.h>
          int main() {
            RWCollectable ct;
            fillCollectable();  // make a collection, somehow
            RWAuditStreamBuffer bcounter, pcounter;
            RWbostream bcount(&bcounter); //ctor takes streambuf pointer
            RWpostream pcount(&pcounter);
          //_
            bcount << ct;
            pcount << ct;
          cout  << "We just counted " << bcounter
                << " bytes from an RWbostream." << endl;
          cout  << "We just counted " << pcounter
                << " bytes from an RWpostream." << endl;
          return 0;
          }





                                                                        PPPPaaaaggggeeee 1111






RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr((((3333CCCC++++++++))))                            RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr((((3333CCCC++++++++))))



RRRReeeellllaaaatttteeeedddd CCCCllllaaaasssssssseeeessss
     RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr may be used as the streambuf for any stream,
     including those derived from RRRRWWWWvvvvoooossssttttrrrreeeeaaaammmm or RRRRWWWWvvvviiiissssttttrrrreeeeaaaammmm, ssssttttrrrrssssttttrrrreeeeaaaammmm,
     iiiiffffssssttttrrrreeeeaaaammmm, ooooffffssssttttrrrreeeeaaaammmm, etc.

GGGGlllloooobbbbaaaallll TTTTyyyyppppeeeeddddeeeeffff
              typedef void (*RWauditFunction)(unsigned char, void*);


     If you wish to do more than count each character handled by the buffer,
     you may provide an RRRRWWWWaaaauuuuddddiiiittttFFFFuuuunnnnccccttttiiiioooonnnn to the constructor. The first
     parameter to this function is a byte provided by the stream.  The second
     parameter is the address of the conter to be manipulated by
     RRRRWWWWAAAAuuuuddddiiiittttFFFFuuuunnnnccccttttiiiioooonnnn.

PPPPuuuubbbblllliiiicccc CCCCoooonnnnssssttttrrrruuuuccccttttoooorrrrssss
              RWAuditStreamBuffer(RWauditFunction=0, void*=0);


     Constructs a new RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr that may be used only to examine and
     count every byte that passes into an oooossssttttrrrreeeeaaaammmm that has the
     RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr instance as its ssssttttrrrreeeeaaaammmmbbbbuuuuffff. It will not forward the
     bytes to any stream, nor accept bytes from a stream. The second argument
     to the constructor allows you to supply storage for the byte count. It is
     optional.

              RWAuditStreamBuffer(istream&, RWauditFunction=0, void*=0);


     Constructs a new RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr that passes bytes from the iiiissssttttrrrreeeeaaaammmm
     on which it is constructed to the iiiissssttttrrrreeeeaaaammmm that has the
     RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr instance as its ssssttttrrrreeeeaaaammmmbbbbuuuuffff.  A typical use would be to
     count or examine the bytes being input from a file through a stream
     derived from RRRRWWWWvvvviiiissssttttrrrreeeeaaaammmm. The second argument to the constructor allows
     you to supply storage for the byte count. It is optional.

              RWAuditStreamBuffer(iostream&, RWauditFunction=0, void*=0);


     Constructs a new RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr that passes bytes to and from the
     ioooossssttttrrrreeeeaaaammmm on which it is constructed to and from the iiiissssttttrrrreeeeaaaammmm that has the
     RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr instance as its ssssttttrrrreeeeaaaammmmbbbbuuuuffff.  A typical use would be to
     count or examine the bytes being transferred to and from a file used to
     store and retrieve changing data. The second argument to the constructor
     allows you to supply storage for the byte count. It is optional.

              RWAuditStreamBuffer(ostream&, RWauditFunction=0, void*=0);


     Constructs a new RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr that passes bytes into the oooossssttttrrrreeeeaaaammmm
     on which it is constructed from the oooossssttttrrrreeeeaaaammmm that has the
     RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr instance as its ssssttttrrrreeeeaaaammmmbbbbuuuuffff.  A typical use would be to



                                                                        PPPPaaaaggggeeee 2222






RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr((((3333CCCC++++++++))))                            RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr((((3333CCCC++++++++))))



     count or examine the bytes being output to a file through a stream
     derived from RRRRWWWWvvvvoooossssttttrrrreeeeaaaammmm. The second argument to the constructor allows
     you to supply storage for the byte count. It is optional.

              RWAuditStreamBuffer(streambuf*, RWauditFunction=0, void*=0);


     Constructs a new RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr that passes bytes into the oooossssttttrrrreeeeaaaammmm
     on which it is constructed from the oooossssttttrrrreeeeaaaammmm that has the
     RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr instance as its ssssttttrrrreeeeaaaammmmbbbbuuuuffff.  A typical use would be to
     count or examine the bytes being output to a file through a stream
     derived from RRRRWWWWvvvvoooossssttttrrrreeeeaaaammmm. The second argument to the constructor allows
     you to supply storage for the byte count. It is optional.

PPPPuuuubbbblllliiiicccc DDDDeeeessssttttrrrruuuuccccttttoooorrrr
              virtual ~RWAuditStreamBuffer();


     We have provided an empty destructor since some compilers complain if
     there is no virtual destructor for a class that has virtual methods.

PPPPuuuubbbblllliiiicccc MMMMeeeemmmmbbbbeeeerrrr OOOOppppeeeerrrraaaattttoooorrrr
              ooooppppeeeerrrraaaattttoooorrrr unsigned long();


     Provides the count of bytes seen so far.

PPPPuuuubbbblllliiiicccc MMMMeeeemmmmbbbbeeeerrrr FFFFuuuunnnnccccttttiiiioooonnnn
              unsigned long
          rrrreeeesssseeeetttt(unsigned long value = 0);


     Resets the count of bytes seen so far.  Returns the current count.

EEEExxxxtttteeeennnnddddeeeedddd EEEExxxxaaaammmmpppplllleeee
              #include <iostream.h>



              #include <fstream.h>
          #include <rw/auditbuf.h>
          #include <rw/pstream.h>
          #include <rw/cstring.h>
          void doCrc (unsigned char c, void* x) {
            *(unsigned char*)x ^= c;
          }
          int main() {
          if(1) { // just a block to control variable lifetime
              unsigned char check = ' ';
              // create an output stream
              ofstream                            op("crc.pst");
              // create an RWAuditStreamBuffer that will do CRC



                                                                        PPPPaaaaggggeeee 3333






RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr((((3333CCCC++++++++))))                            RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr((((3333CCCC++++++++))))



              RWAuditStreamBuffer               crcb(op,doCrc,&check);
              // create an RWpostream to put the data through.
          RWpostream                           p(&crcb);
              // now send some random stuff to the stream
              p << RWCString("The value of Tools.h++ is at least ");
              p << (int)4;
              p << RWCString(" times that of the next best library!0) ;
              p << RWCString("Pi is about ") << (double)3.14159 << '.';
              // finally, save the sum on the stream itself.
          p << (unsigned int)check; // alters check, _after_ saving it...
              // just for fun, print out some statistics:
              cout << "We just saved " << crcb
                   << " bytes of data to the file." << endl;
              cout << "The checksum for those bytes was " <<check << endl;
          } // end of block
            // now read the data back in, checking to see if it survived.
            unsigned char check = ' ';
            // create an instream
            ifstream                            ip("crc.pst");
            // create an RWAuditStreamBuffer that will do CRC
            RWAuditStreamBuffer               crcb(ip,doCrc,&check);
            // create an RWpistream to interpret the bytes
            RWpistream                           p(&crcb);
            RWCString first, mid1, mid2;
            int value;
            double pi;
            char pnc;
            unsigned int savedCRC;
            unsigned char matchCRC;
            // read in the data. Don't read the checksum yet!
            p >> first >> value >> mid1 >> mid2 >> pi >> pnc;
            // save the checksum
            matchCRC = check;
            // Now it is safe to alter the running checksum by reading in
            // the one saved in the file.
          p >> savedCRC;
            if(savedCRC != matchCRC) {
              cout << "Checksum error. Saved CRC: " << savedCRC
                   << " built CRC: " << matchCRC << dec << endl;
            }
            else {
              cout << "The message was: " << endl;
              cout << first << value << mid1 << mid2 << pi << pnc << endl;
            }
            // just for fun, print out some statistics:
            cout  << "We just read " << crcb
                  << " bytes of data from the file." << endl;
            cout  << "The checksum was " << matchCRC << flush;
            cout  << " and the saved checksum was " << savedCRC << endl;
          return 0;
          }




                                                                        PPPPaaaaggggeeee 4444






RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr((((3333CCCC++++++++))))                            RRRRWWWWAAAAuuuuddddiiiittttSSSSttttrrrreeeeaaaammmmBBBBuuuuffffffffeeeerrrr((((3333CCCC++++++++))))























































                                                                        PPPPaaaaggggeeee 5555